/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 86185
 * Date: 2023-03-19
 * Time: 14:29
 */

class Animal{
    public String name;
    public int age;
    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public void eat () {
        System.out.println(this.name+"eating");
    }
}
class Dog extends Animal{
    public Dog(){
        super("fa",15);
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    public void bark() {
        System.out.println(this.name+" wolf~");
    }
    @Override
    public void eat() {
        System.out.println("gou liang");
    }
    //重写：override
    //方法名称相同，参数列表相同（个数，顺序，类型），返回值类型相同
    //重载：overload
    //方法名称相同，参数列表不同（个数，顺序，类型），返回值无要求

    //什么情况不能重写？
    //被private，static，final修饰的方法不能成功写
    //子类的访问修饰限定符一定要大于等于父类的访问修饰限定符
    //构造方法不能被重写
}
class Cat extends Animal{
    public Cat() {
        super("haha",10);
    }
    public void mao() {
        System.out.println(this.name+"miao~");
    }
    @Override
    public void eat() {
        System.out.println("maoliang");
    }
}
//多态发生的条件：
//1. 必须在继承体系下
//2. 子类必须要对父类中方法进行重写
//3. 通过父类的引用调用重写的方法
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("laifu",4);

        Dog dog = (Dog) animal;//向下转型
        dog.bark();
        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.mao();
        }
//
    }
    public static void testF(Animal animal) {
        animal.eat();
    }
    public static Animal testF2() {
        return new Dog();
    }

    public static void main2(String[] args) {
        Animal animal = new Dog("laifu",4);//直接赋值

        Dog dog = new Dog("laifu",4);
        testF(dog);//方法传参
        Animal animal1 = testF2();//方法返回
        animal1.eat();

        Cat cat = new Cat();
        testF(cat);//方法传参

        //向上转型发生的时机
        //1. 直接赋值
        //2. 方法传参
        //3. 方法返回
    }
    public static void main1(String[] args) {
//        Dog dog = new Dog();
//        dog.eat();
//        Cat cat = new Cat();
//        cat.eat();
        Animal animal = new Dog("laifu",4);//向上转型
        //此时只能调用animal自己的方法
        //小范围到大范围的转换
        animal.eat();//运行时绑定，动态绑定
    }
}
